// 购物车状态
import {deleteCart, findCart, getNewCartGoods, insertCart, mergeCart, updateCart} from "@/api/cart";

export default {
    namespaced: true,
    state: () => {
        return {
            list: []
        }
    },
    mutations: {
        // 本地：id skuId name picture price nowPrice count attrsText selected stock isEffective
        insertCart(state, goods) {
            const sameIndex = state.list.findIndex(item => item.skuId === goods.skuId)
            if (sameIndex > -1) {
                goods.count = state.list[sameIndex].count + goods.count
                state.list.splice(sameIndex, 1)
            }
            state.list.unshift(goods)

        },
        // 修改购物车商品
        updateCart(state, goods) {
            // goods中字段有可能不完整，goods有的信息才去修改。
            // 1. goods中必需又skuId，才能找到对应的商品信息
            const updateGoods = state.list.find(item => item.skuId === goods.skuId)
            for (const key in goods) {
                if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
                    updateGoods[key] = goods[key]
                }
            }
        },
        // 删除购物车商品
        deleteCart(state, skuId) {
            const index = state.list.findIndex(item => item.skuId === skuId)
            state.list.splice(index, 1)
        },
        // 设置购物车列表
        setCartList(state, list) {
            state.list = list
        }
    },
    actions: {
        async insertCart(ctx, payload) {

            return new Promise((resolve, reject) => {
                if (ctx.rootGetters.token) {
                    // 已登录
                    insertCart({skuId: payload.skuId, count: payload.count}).then(() => {
                        return findCart()
                    }).then(data => {
                        ctx.commit('setCartList', data.result)
                        resolve()
                    })
                } else {
                    // 未登录
                    ctx.commit('insertCart', payload)
                    resolve()
                }
            })
        },
        // 获取购物车列表
        findCartList(ctx) {
            return new Promise((resolve, reject) => {
                if (ctx.rootGetters.token) {
                    // 登录
                    findCart().then(data => {
                        ctx.commit('setCartList', data.result)
                        resolve()
                    })
                } else {
                    // 本地
                    // Promise.all() 可以并列发送多个请求，等所有请求成功，调用then
                    // Promise.race() 可以并列发送多个请求，等最快的请求成功，调用then
                    // 传参事promise数组
                    const promiseArr = ctx.state.list.map(item => {
                        // 返回接口函数的调用
                        return getNewCartGoods(item.skuId)
                    })
                    Promise.all(promiseArr).then(dataArr => {
                        dataArr.forEach((data, i) => {
                            ctx.commit('updateCart', {skuId: ctx.state.list[i].skuId, ...data.result})
                        })
                        resolve()
                    }).catch(e => {
                        reject(e)
                    })
                }
            })
        },
        // 删除购物车商品
        deleteCart(ctx, skuId) {
            return new Promise((resolve, reject) => {
                if (ctx.rootGetters.token) {
                    // 登录
                    deleteCart([skuId]).then(() => {
                        return ctx.dispatch('findCartList')
                    }).then((data) => {
                        ctx.commit('setCartList', data.result)
                        resolve()
                    })
                } else {
                    // 本地
                    ctx.commit('deleteCart', skuId)
                    resolve()
                }
            })
        },
        // 修改购物车商品
        updateCart(ctx, goods) {
            // goods 中：必须有skuId，其他想修改的属性 selected  count
            return new Promise((resolve, reject) => {
                if (ctx.rootGetters.token) {
                    // 登录
                    updateCart(goods).then(() => {
                        return ctx.dispatch('findCartList')
                    }).then((data) => {
                        resolve()
                    })
                } else {
                    // 本地
                    ctx.commit('updateCart', goods)
                    resolve()
                }
            })
        },
        // 批量删除选中商品
        batchDeleteCart(ctx) {
            return new Promise((resolve, reject) => {
                if (ctx.rootGetters.token) {
                    // 登录
                    const ids = ctx.rootGetters.selectedList.map(item => item.skuId)
                    deleteCart(ids).then(() => {
                        return ctx.dispatch('findCartList')
                    }).then((data) => {
                        ctx.commit('setCartList', data.result)
                        resolve()
                    })
                } else {
                    // 本地
                    // 1. 获取选中商品列表，进行遍历调用deleteCart mutataions函数
                    ctx.rootGetters.selectedList.forEach(item => {
                        ctx.commit('deleteCart', item.skuId)
                    })
                    resolve()
                }
            })
        },
        // 合并购物车
        async mergeCart(ctx) {
            // 准备合并的参数
            const cartList = ctx.state.list.map(goods => {
                return {
                    skuId: goods.skuId,
                    selected: goods.selected,
                    count: goods.count
                }
            })
            await mergeCart(cartList)
            // 合并成功，清空本地购物车
            ctx.commit('setCartList', [])
        },

    },

}